/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package edu.uci.quinto.Managers;

import edu.uci.quinto.Pojos.TipoEstado;
import edu.uci.quinto.Util.HibernateUtil;
import java.util.ArrayList;
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
/**
 *
 * @author Ale
 */
public class TipoEstadoManager{
     
    Session session = null;
    public String mess = "";
    int maxResults = 100;

    public TipoEstadoManager() {
        this.session=HibernateUtil.getSessionFactory().getCurrentSession();
    }

    //Obtiene el dato de acuerdo al id
    public TipoEstado getTipoEstado (int id){

     //llamo al beans tipodeactividad
     TipoEstado tipoEstado= null;
     //verifico que la sesion este abierta
     if (!session.isOpen())
         this.session =HibernateUtil.getSessionFactory().getCurrentSession();
     //abri una trasaccion
     org.hibernate.Transaction tx= session.beginTransaction();

         try{
           //consulta
           Query q= session.createQuery("from TipoEstado where id=" + id);
           tipoEstado= (TipoEstado) q.uniqueResult();
           tx.commit();
         }catch (HibernateException ex) {
            mess = ex.getMessage();
            tx.rollback();
            ex.printStackTrace();
        }
     //retorno el objeto de acuerdo al id , que se le pasa en la consulta
     return tipoEstado;
 }


    //obtiene la lista de registro de la tabla
    //de acuerdo a la cantidad de registros
    public List getTipoEstado (int pageSize, int page) {

        //creo una lista le asigno null
        List <TipoEstado> tipoEstadoList=new ArrayList();
       //verifico si ta abierta la sesion
        if(!session.isOpen())
           this.session= HibernateUtil.getSessionFactory().getCurrentSession();
      //creo una unidad de trabajo para la trasaccion
      org.hibernate.Transaction tx=session.beginTransaction();

       try{
           //realizo una consulta ordenada por el id de la tabla
           Query q=session.createQuery("from TipoEstado order by id");
           tipoEstadoList= (List <TipoEstado>) q.list().subList(page * pageSize, (page+1)*pageSize);
           //hago un commit para la transaccion
           tx.commit();
       }
       catch (HibernateException ex) {
            mess = ex.getMessage();
            //rollback-paso atras-en el caso existiera un error
            tx.rollback();
            ex.printStackTrace();
        }
   return tipoEstadoList;
   }

   ////obtiene la lista de registro de la tabla
    public List getTipoEstado(){
        //creo una lista inicializando en null
        List <TipoEstado> tipoEstadoList= new ArrayList();
        //verifico que la sesion se encuentre abierta
        if(!session.isOpen())
            this.session = HibernateUtil.getSessionFactory().getCurrentSession();
        //creo una unidad de trabajo para la tansaccion
        org.hibernate.Transaction tx = session.beginTransaction();
        try {
            //realizo una consulta ordenada por el id
            Query q = session.createQuery ("from TipoEstado order by id");
            //cargo la lista
            tipoEstadoList= (List <TipoEstado>) q.list();
            tx.commit();
        }
        catch (HibernateException ex) {
            mess = ex.getMessage();
            tx.rollback();
            ex.printStackTrace();
        }
     return tipoEstadoList;
    }
    //busqueda de registros
    public List searchTipoEstado (TipoEstado tipoEstadoSample){
        //creo una lista inicializo a null
        List <TipoEstado> tipoEstadoList= new ArrayList();
        //verifico si ta abierta la sesion
        if(!session.isOpen())
           //obtengo la sesion concurrente
            this.session=HibernateUtil.getSessionFactory().getCurrentSession();
           //creo una unidad de trabajo para las transacciones
           org.hibernate.Transaction tx= session.beginTransaction();
           //Acompaña a Hibernate una API de consultas por criterios intuitiva y extensible.
           //instancio a la clase tipodeactividad
           TipoEstado tipoEstado=new TipoEstado();
           //seteo el valor de descripcion
           tipoEstado.setDescripcion(tipoEstadoSample.getDescripcion());
          
           /*La clase org.hibernate.criterion.Example
           /le permite construir un criterio de consulta
            a partir de una instancia dada.

           Puede modificar la aplicación del Example.

                    Example example = Example.create(cat)

                   .excludeZeroes()           //exclude zero valued properties

                    .excludeProperty("color")  //exclude the property named "color"

                    .ignoreCase()              //perform case insensitive string comparisons

                    .enableLike();             //use like for string comparisons

                    List results = session.createCriteria(Cat.class)

                    .add(example)

                    .list();
           */
           //utilizo el objeto tipodeactividad para construir el criterio instanciando la clase
           Example example=Example.create(tipoEstado).ignoreCase().excludeZeroes().enableLike(MatchMode.ANYWHERE);


         try {
              //la lista
              tipoEstadoList = session.createCriteria(TipoEstado.class).add(example).list();
              //concreto la transaccion
             tx.commit();
        }
        catch (HibernateException ex) {
            mess = ex.getMessage();
            //paso atras en el caso de un error
            tx.rollback();
            ex.printStackTrace();
        }


        if (tipoEstadoList==null){
        tipoEstadoList = new ArrayList();
        }


           return tipoEstadoList;
    }

   //*************************************************************************************************/
    /*GUARDAR*/
   //*************************************************************************************************/
      public boolean saveCargo (TipoEstado tipoEstado)
    {
        if(!session.isOpen())
            this.session = HibernateUtil.getSessionFactory().getCurrentSession();

        org.hibernate.Transaction tx = session.beginTransaction();
        try
        {
            session.saveOrUpdate(tipoEstado);
            tx.commit();
        }
        catch (HibernateException ex) {
            mess = ex.getMessage();
            tx.rollback();
            ex.printStackTrace();
            return false;
        }
        return true;
    }

    //********************************************************************************//
      /*BORRAR*/
    //*****************************************************************************//
   public boolean deleteCargo (TipoEstado tipoEstado)
    {
        if(!session.isOpen())
            this.session = HibernateUtil.getSessionFactory().getCurrentSession();

        org.hibernate.Transaction tx = session.beginTransaction();
        try
        {
            session.delete(tipoEstado);
            tx.commit();
        }
        catch (HibernateException ex) {
            mess = ex.getMessage();
            tx.rollback();
            ex.printStackTrace();
            return false;
        }
        return true;
    }
/**  
        * Cantidad de registros de una entidad  
        * @return  
        */  
       public int getListCount() {  
           Number count = 0;  
           // obtener la sesion actual  
           if(!session.isOpen())
            this.session = HibernateUtil.getSessionFactory().getCurrentSession();
            org.hibernate.Transaction tx = session.beginTransaction();
           try {  
               // comenzar la transaccion  
               session.beginTransaction();  
               // obtener la cantidad  
               count = (Number) session.createCriteria(TipoEstado.class.getClass()).setProjection(Projections.rowCount()).uniqueResult();  
               // confirmar transaccion  
               session.getTransaction().commit();  
           } catch (Exception e) {  
               
               System.out.println("Error en getListCount: " + e);  
               // deshacer transaccion  
               tx.rollback();  
           }  
           return count.intValue();  
       }
              /**  
        * Comprobar si esta repetido un objeto a partir de un valor de un atributo  
        * @param attr  
        * @param value  
        * @return  
        */  
       public boolean checkRepeated(String attr, String value){  
           Object obj = new Object();  
           // obtener la sesion actual  
           if(!session.isOpen())
            this.session = HibernateUtil.getSessionFactory().getCurrentSession();
           
           org.hibernate.Transaction tx = session.beginTransaction();
           try {  
               // comenzar la transaccion  
               session.beginTransaction();  
               // cargar objeto por clave  
               obj = session.createCriteria(TipoEstado.class.getClass()).add(Restrictions.eq(attr, value)).uniqueResult();  
               // confirmar transaccion  
               session.getTransaction().commit();  
           } catch (Exception e) {  
               System.out.println("Error en checkRepeated: " + e);  
               // deshacer transaccion  
               tx.rollback();  
           }  
           return obj != null ? true : false;  
       }  

}
  
